home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / src.arc / SESSION.C < prev    next >
C/C++ Source or Header  |  1989-08-19  |  8KB  |  403 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "socket.h"
  7. #include "ftpcli.h"
  8. #include "telnet.h"
  9. #include "icmp.h"
  10. #include "ax25tnc.h"
  11. #include "session.h"
  12. #include "cmdparse.h"
  13. #include "timer.h"
  14. #include "proc.h"
  15. #include "tty.h"
  16. #include "commands.h"
  17.  
  18. struct session *Sessions;
  19. struct session *Current;
  20. int Mode = CMD_MODE;
  21.  
  22. char Notval[] = "Not a valid control block\n";
  23. static char Badsess[] = "Invalid session\n";
  24. char *Sestypes[] = {
  25.     "",
  26.     "Telnet",
  27.     "FTP",
  28.     "AX25",
  29.     "Finger",
  30.     "Ping",
  31.     "NET/ROM"
  32. };
  33.  
  34. /* Convert a character string containing a decimal session index number 
  35.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  36.  * If the index is out of range or unused, return NULLSESSION.
  37.  */
  38. struct session *
  39. sessptr(cp)
  40. char *cp;
  41. {
  42.     register struct session *sp;
  43.     unsigned int i;
  44.  
  45.     if(cp == NULLCHAR){
  46.         sp = Current;
  47.     } else {
  48.         i = (unsigned)atoi(cp);
  49.         if(i >= Nsessions)
  50.             sp = NULLSESSION;
  51.         else
  52.             sp = &Sessions[i];
  53.     }
  54.     if(sp == NULLSESSION || sp->type == FREE)
  55.         sp = NULLSESSION;
  56.  
  57.     return sp;
  58. }
  59.  
  60. /* Select and display sessions */
  61. int
  62. dosession(argc,argv,p)
  63. int argc;
  64. char *argv[];
  65. void *p;
  66. {
  67.     struct session *sp;
  68.     struct sockaddr fsocket;
  69.     int i,k,s;
  70.     int r,t;
  71.     char *cp;
  72.  
  73.     sp = (struct session *)p;
  74.  
  75.     if(argc > 1){
  76.         if((sp = sessptr(argv[1])) != NULLSESSION){
  77.             go(0,NULL,sp);
  78.         } else
  79.             printf("Session %s not active\n",argv[1]);
  80.         return 0;
  81.     }
  82.     printf(" #  S#  Type     Rcv-Q Snd-Q State        Remote socket\n");
  83.     for(sp=Sessions; sp < &Sessions[Nsessions];sp++){
  84.         if(sp->type == FREE)
  85.             continue;
  86.  
  87.         i = SOCKSIZE;
  88.         s = sp->s;
  89.         k = getpeername(s,(char *)&fsocket,&i);
  90.         r = socklen(s,0);
  91.         t = socklen(s,1);
  92.         cp = sockstate(s);
  93.         printf("%c%-3u%-4d%-8s%6d%6d %-13s",
  94.          (Current == sp)? '*':' ',
  95.          (unsigned)(sp - Sessions),
  96.          s,
  97.          Sestypes[sp->type],
  98.          r,
  99.          t,
  100.          (cp != NULLCHAR) ? cp : "");
  101.         if(sp->name != NULLCHAR)
  102.             printf("%s ",sp->name);
  103.         if(k == 0)
  104.             printf("(%s)",psocket(&fsocket));
  105.  
  106.         if(sp->rfile != NULLCHAR || sp->ufile != NULLCHAR)
  107.             printf("\t");
  108.         if(sp->rfile != NULLCHAR)
  109.             printf("Record: %s ",sp->rfile);
  110.         if(sp->ufile != NULLCHAR)
  111.             printf("Upload: %s",sp->ufile);
  112.         printf("\n");
  113.         if(sp->type == FTP && (s = sp->cb.ftp->data) != -1){
  114.             /* Display data channel, if any */
  115.             i = SOCKSIZE;
  116.             k = getpeername(s,(char *)&fsocket,&i);
  117.             r = socklen(s,0);
  118.             t = socklen(s,1);
  119.             cp = sockstate(s);
  120.             printf("    %-4d%-8s%6d%6d %-13s%s",
  121.              s,
  122.              Sestypes[sp->type],
  123.              r,
  124.              t,
  125.              (cp != NULLCHAR) ? cp : "",
  126.              (sp->name != NULLCHAR) ? sp->name : "");
  127.             if(k == 0)
  128.                 printf(" (%s)",psocket(&fsocket));
  129.             printf("\n");
  130.         }
  131.     }
  132.     return 0;
  133. }
  134. /* Resume current session, and wait for it */
  135. int
  136. go(argc,argv,p)
  137. int argc;
  138. char *argv[];
  139. void *p;
  140. {
  141.     struct session *sp;
  142.  
  143.     sp = (struct session *)p;
  144.     if(sp == NULLSESSION || sp->type == FREE)
  145.         return 0;
  146.     Current = sp;
  147.     ttysetmode(sp->ttymode);
  148.     Mode = CONV_MODE;
  149.     psignal(sp,0);
  150.     switch(sp->type){
  151.     case TELNET:
  152.         pwait(sp->cb.telnet->output);
  153.         break;
  154.     case FTP:
  155.         pwait(sp->cb.ftp->output);
  156.         break;
  157.     case NRSESSION:
  158.     case AX25TNC:
  159.         pwait(sp->cb.ax25->output);
  160.         break;
  161.     case PING:
  162.         pwait(sp->cb.ping->proc);
  163.         break;
  164.     }
  165.     return 0;
  166. }
  167. int
  168. doclose(argc,argv,p)
  169. int argc;
  170. char *argv[];
  171. void *p;
  172. {
  173.     struct session *sp;
  174.  
  175.     sp = (struct session *)p;
  176.     if(argc > 1)
  177.         sp = sessptr(argv[1]);
  178.  
  179.     if(sp == NULLSESSION){
  180.         printf(Badsess);
  181.         return -1;
  182.     }
  183.     shutdown(sp->s,1);
  184.     return 0;
  185. }
  186. int
  187. doreset(argc,argv,p)
  188. int argc;
  189. char *argv[];
  190. void *p;
  191. {
  192.     struct session *sp;
  193.  
  194.     sp = (struct session *)p;
  195.     if(argc > 1)
  196.         sp = sessptr(argv[1]);
  197.  
  198.     if(sp == NULLSESSION){
  199.         printf(Badsess);
  200.         return -1;
  201.     }
  202.     /* Unwedge anyone waiting for a domain resolution, etc */
  203.     switch(sp->type){
  204.     case FTP:
  205.         alert(sp->cb.ftp->output,-1);
  206.         break;
  207.     case TELNET:
  208.         alert(sp->cb.telnet->output,-1);
  209.         break;
  210.     case FINGER:
  211.         alert(sp->cb.finger,-1);
  212.         break;
  213.     case AX25TNC:
  214.         break;
  215.     case PING:
  216.         alert(sp->cb.ping->proc,-1);
  217.         break;
  218.     case NRSESSION:
  219.         break;
  220.     }
  221.     shutdown(sp->s,2);
  222.     if(sp->type == FTP)
  223.         shutdown(sp->cb.ftp->data,2);
  224.     return 0;
  225. }
  226. int
  227. dokick(argc,argv,p)
  228. int argc;
  229. char *argv[];
  230. void *p;
  231. {
  232.     struct session *sp;
  233.  
  234.     sp = (struct session *)p;
  235.     if(argc > 1)
  236.         sp = sessptr(argv[1]);
  237.  
  238.     if(sp == NULLSESSION){
  239.         printf(Badsess);
  240.         return -1;
  241.     }
  242.     sockkick(sp->s);
  243.     if(sp->type == FTP)
  244.         sockkick(sp->cb.ftp->data);
  245.     return 0;
  246. }
  247.  
  248. struct session *
  249. newsession(name,type)
  250. char *name;
  251. int type;
  252. {
  253.     register struct session *sp;
  254.  
  255.     for(sp=Sessions;sp < &Sessions[Nsessions];sp++){
  256.         if(sp->type == FREE){
  257.             sp->type = type;
  258.             sp->s = -1;
  259.             if(name != NULLCHAR)
  260.                 sp->name = strdup(name);
  261.  
  262.             return sp;
  263.         }
  264.     }
  265.     return NULLSESSION;
  266. }
  267. void
  268. freesession(sp)
  269. struct session *sp;
  270. {
  271.     if(sp == NULLSESSION)
  272.         return;
  273.     if(sp->s != -1)
  274.         close_s(sp->s);
  275.     free_q(&sp->input);
  276.     if(sp->record != NULLFILE){
  277.         fclose(sp->record);
  278.         sp->record = NULLFILE;
  279.     }
  280.     free(sp->rfile);
  281.     sp->rfile = NULLCHAR;
  282.     if(sp->upload != NULLFILE){
  283.         fclose(sp->upload);
  284.         sp->upload = NULLFILE;
  285.     }
  286.     free(sp->ufile);
  287.     sp->ufile = NULLCHAR;
  288.     free(sp->name);
  289.     sp->name = NULLCHAR;
  290.     sp->type = FREE;
  291.     if(Current == sp){
  292.         Current = NULLSESSION;
  293.         Mode = CMD_MODE;
  294.     }
  295. }
  296. /* Control session recording */
  297. int
  298. dorecord(argc,argv,p)
  299. int argc;
  300. char *argv[];
  301. void *p;
  302. {
  303.     struct session *sp;
  304.  
  305.     sp = (struct session *)p;
  306.     if(sp == NULLSESSION){
  307.         printf("No current session\n");
  308.         return 1;
  309.     }
  310.     if(argc > 1){
  311.         if(sp->rfile != NULLCHAR){
  312.             fclose(sp->record);
  313.             free(sp->rfile);
  314.             sp->record = NULLFILE;
  315.             sp->rfile = NULLCHAR;
  316.         }
  317.         /* Open new record file, unless file name is "off", which means
  318.          * disable recording
  319.          */
  320.         if(strcmp(argv[1],"off") != 0){
  321.             if((sp->record = fopen(argv[1],APPEND_TEXT)) == NULLFILE)
  322.                 printf("Can't open %s: %s\n",argv[1],sys_errlist[errno]);
  323.             else
  324.                 sp->rfile = strdup(argv[1]);
  325.         }
  326.     }
  327.     if(sp->rfile != NULLCHAR)
  328.         printf("Recording into %s\n",sp->rfile);
  329.     else
  330.         printf("Recording off\n");
  331.     return 0;
  332. }
  333. /* Control file transmission */
  334. int
  335. doupload(argc,argv,p)
  336. int argc;
  337. char *argv[];
  338. void *p;
  339. {
  340.     struct telnet *tn;
  341.     struct ax25tnc *axp;
  342.     struct session *sp;
  343.  
  344.     sp = (struct session *)p;
  345.     if(sp == NULLSESSION){
  346.         printf("No current session\n");
  347.         return 1;
  348.     }
  349.     if(argc < 2){
  350.         if(sp->ufile != NULLCHAR)
  351.             printf("Uploading %s\n",sp->ufile);
  352.         else
  353.             printf("Uploading off\n");
  354.         return 0;
  355.     }
  356.     switch(sp->type){
  357.     case TELNET:
  358.         tn = sp->cb.telnet;
  359.         break;
  360.     case NRSESSION:
  361.     case AX25TNC:
  362.         axp = sp->cb.ax25;
  363.         break;
  364.     default:
  365.         printf("Uploading not supported\n");
  366.         return 1;
  367.     }
  368.     if(strcmp(argv[1],"stop") == 0 && sp->upload != NULLFILE){
  369.         /* Abort upload */
  370.         fclose(sp->upload);
  371.         sp->upload = NULLFILE;
  372.         free(sp->ufile);
  373.         sp->ufile = NULLCHAR;
  374.         if(tn != NULLTN){
  375.             killproc(tn->upload);
  376.             tn->upload = NULLPROC;
  377.         } else if(axp != NULLTNC){
  378.             killproc(axp->upload);
  379.             axp->upload = NULLPROC;
  380.         }
  381.         return 0;
  382.     }
  383.     /* Open upload file */
  384.     if((sp->upload = fopen(argv[1],READ_TEXT)) == NULLFILE){
  385.         printf("Can't read %s: %s\n",argv[1],sys_errlist[errno]);
  386.         return 1;
  387.     }
  388.     sp->ufile = strdup(argv[1]);
  389.     /* All set, invoke the upload process */
  390.     switch(sp->type){
  391. #ifdef    AX25
  392.     case NRSESSION:
  393.     case AX25TNC:
  394.         axp->upload = newproc("upload",1024,ax_upload,0,sp,NULL);
  395.         break;
  396. #endif
  397.     case TELNET:
  398.         tn->upload = newproc("upload",1024,tel_upload,0,sp,NULL);
  399.         break;
  400.     }
  401.     return 0;
  402. }
  403.